home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / qix / polyfil0.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-01-28  |  3.9 KB  |  194 lines
  1. /*
  2.     File:   polyfill.c
  3.     By:     Don Hatch
  4.   
  5.     For:    Yaq (Yet Another Qix)
  6.  
  7.     Cute randomized recursive seed fill routine,
  8.     until bug in the real one gets fixed
  9.   
  10.     Just a little note to remind whom-ever:
  11.   
  12.     The coordinate values (x and y) used in polyfill() are NOT the actual
  13.     coordinate values of the board.  Instead, they are twice the size of
  14.     the board and represent the quadrants within a cell.
  15. */
  16.  
  17. #include    "qix.h"
  18.  
  19.  
  20. /* Filled areas look-up tables */
  21. int fill_table[2][2] = {    /* Filled state bits */
  22.     {CL_PNT_UL, CL_PNT_LL},
  23.     {CL_PNT_UR, CL_PNT_LR}
  24. };
  25. int edge_table[4][2][2] = {    /* Edge state bits */
  26.     {            /* Look left */
  27.     {0, 0},
  28.     {CL_LN_UP, CL_LN_DN}
  29.     },
  30.     {            /* Look right */
  31.     {CL_LN_UP, CL_LN_DN},
  32.     {0, 0}
  33.     },
  34.     {            /* Look up */
  35.     {0, CL_LN_LF},
  36.     {0, CL_LN_RT}
  37.     },
  38.     {            /* Look down */
  39.     {CL_LN_LF, 0},
  40.     {CL_LN_RT, 0}
  41.     }
  42. };
  43.  
  44. /* Macro for testing and changing the current (x,y) points state */
  45.  
  46. #define pttest(x,y)    (board[(x)/2][(y)/2] & fill_table[(x)&1][(y)&1])
  47.  
  48.  
  49. #define lntest(x,y,d) (board[(x)/2][(y)/2] & edge_table[d-LEFT][(x)&1][(y)&1])
  50.  
  51. #define ptclr(x,y) \
  52.     (board[(x)/2][(y)/2] &= ~fill_table[(x)&1][(y)&1]), region_score++;
  53.  
  54. #ifndef DEBUG
  55. #define ptset(x,y) \
  56.     (board[(x)/2][(y)/2] |= fill_table[(x)&1][(y)&1]), region_score++;
  57.  
  58. #else
  59.  
  60. ptset(x,y)
  61. register int x,y;
  62. {
  63.     extern region_score;
  64.     board[x/2][y/2] |= fill_table[x&1][y&1], region_score++;
  65.     if (debug)
  66.     /* pw_put(draw_win, convert_x(x/2), convert_y(y/2)-3, 1); */
  67.     box(convert_x(x/2)-3 + ((x&1)*4), convert_y(y/2)-3 + ((y&1)*4),
  68.         convert_x(x/2)-3 + ((x&1)*4)+2, convert_y(y/2)-3 + ((y&1)*4)+2,PIX_SRC);
  69. }
  70. #endif DEBUG
  71.  
  72. static region_score;
  73. static depth = 0;
  74.  
  75. int seedfill1(), seedfill2(), seedfill3(), seedfill4();
  76. int (*seedfills[])() = {seedfill1, seedfill2, seedfill3, seedfill4};
  77. #define seedfill (seedfills[(rand()>>5) % 4])
  78.  
  79. /* polyfill(x, y) - Flood the enclosed region found to surround (x,y) */
  80. polyfill(x, y)
  81. register int x, y;
  82. {
  83.     region_score = 0;
  84.     seedfill(x,y);
  85.     return region_score;
  86. }
  87. static
  88. seedfill1(x, y)
  89. register int x, y;
  90. {
  91.     ++depth;
  92.     if (depth == toodeep) {
  93.     printf("Too deep! stack depth exceeded %d\n",toodeep);
  94.     depth--;
  95.     return;
  96.     }
  97.     if (pttest(x, y)) {
  98.     depth--;
  99.     return;
  100.     }
  101.     /* Fill in initial point */
  102.     ptset(x, y);
  103.     if (!lntest(x, y, LEFT))
  104.     seedfill(x - 1, y);
  105.     if (!lntest(x, y, DOWN))
  106.     seedfill(x, y + 1);
  107.     if (!lntest(x, y, RIGHT))
  108.     seedfill(x + 1, y);
  109.     if (!lntest(x, y, UP))
  110.     seedfill(x, y - 1);
  111.     depth--;
  112. }
  113.  
  114. static
  115. seedfill2(x, y)
  116. register int x, y;
  117. {
  118.     ++depth;
  119.     if (depth == toodeep) {
  120.     printf("Too deep! stack depth exceeded %d\n",toodeep);
  121.     depth--;
  122.     return;
  123.     }
  124.     if (pttest(x, y)) {
  125.     depth--;
  126.     return;
  127.     }
  128.     /* Fill in initial point */
  129.     ptset(x, y);
  130.     if (!lntest(x, y, RIGHT))
  131.     seedfill(x + 1, y);
  132.     if (!lntest(x, y, UP))
  133.     seedfill(x, y - 1);
  134.     if (!lntest(x, y, LEFT))
  135.     seedfill(x - 1, y);
  136.     if (!lntest(x, y, DOWN))
  137.     seedfill(x, y + 1);
  138.     depth--;
  139. }
  140.  
  141. static
  142. seedfill3(x, y)
  143. register int x, y;
  144. {
  145.     ++depth;
  146.     if (depth == toodeep) {
  147.     printf("Too deep! stack depth exceeded %d\n",toodeep);
  148.     depth--;
  149.     return;
  150.     }
  151.     if (pttest(x, y)) {
  152.     depth--;
  153.     return;
  154.     }
  155.     /* Fill in initial point */
  156.     ptset(x, y);
  157.     if (!lntest(x, y, UP))
  158.     seedfill(x, y - 1);
  159.     if (!lntest(x, y, LEFT))
  160.     seedfill(x - 1, y);
  161.     if (!lntest(x, y, DOWN))
  162.     seedfill(x, y + 1);
  163.     if (!lntest(x, y, RIGHT))
  164.     seedfill(x + 1, y);
  165.     depth--;
  166. }
  167.  
  168. static
  169. seedfill4(x, y)
  170. register int x, y;
  171. {
  172.     ++depth;
  173.     if (depth == toodeep) {
  174.     printf("Too deep! stack depth exceeded %d\n",toodeep);
  175.     depth--;
  176.     return;
  177.     }
  178.     if (pttest(x, y)) {
  179.     depth--;
  180.     return;
  181.     }
  182.     /* Fill in initial point */
  183.     ptset(x, y);
  184.     if (!lntest(x, y, DOWN))
  185.     seedfill(x, y + 1);
  186.     if (!lntest(x, y, UP))
  187.     seedfill(x, y - 1);
  188.     if (!lntest(x, y, RIGHT))
  189.     seedfill(x + 1, y);
  190.     if (!lntest(x, y, LEFT))
  191.     seedfill(x - 1, y);
  192.     depth--;
  193. }
  194.